/**
 * 缓存好友列表、聊天记录、动态等数据
 * Created by yangxin on 2017/1/5.
 */
import * as constants from 'src/AppConstants'
import utils from 'commons/utils'

import PouchDB from 'pouchdb-browser'

// 本地数据库
const DB_FRIENDS = 'JXWY_FRIENDS'      // 好友表
const DB_DYNAMICS = 'JXWY_DYNAMICS'    // 动态列表
const DBS = [DB_FRIENDS, DB_DYNAMICS]
const DB_INSTANCES = {}

// config
//PouchDB.debug.enable('*')                   // 开启pouchdb日志
PouchDB.debug.disable()
PouchDB.plugin(require('pouchdb-find'))     // 使用查询插件
PouchDB.on('created', function (dbName) {
  console.info(`${dbName} db create success`)
  if (dbName === DB_FRIENDS) {    // 创建索引
    DB_INSTANCES[dbName].createIndex({
      index: {
        fields: ['uid', 'fid']
      },
      name: 'index_friend_uid_fid',
      type: 'json',
    }).then(function (res) {
      console.log(`create ${dbName} index result: `, res)
    })
  }
});
PouchDB.on('destroyed', function (dbName) {
  console.info(`${dbName} db destory success`)
});

/**
 * 初始化
 * @param store
 */
const init = function (vue) {
  DBS.forEach((dbName) => {
    DB_INSTANCES[dbName] = new PouchDB(dbName)
  })
  syncCache(vue)
}

/**
 * 释放数据库连接
 * @param store
 */
const release = function () {
  DBS.forEach((dbName) => {
    DB_INSTANCES[dbName].close().then(function () {
      console.info(`${dbName} close success`)
    })
  })
}

/**
 * 清除数据库缓存
 */
const clearDBCache = function () {
  DBS.forEach((dbName) => {
    if (DB_INSTANCES[dbName]) {
      DB_INSTANCES[dbName].destroy().then(function () {
        console.info(`${dbName} remove success`)
      }).catch((err) => {
        console.warn(`${dbName} remove error: ${err}`)
      })
    }
  })
}

/**
 * 同步本地和服务器的缓存数据
 * @param vue Vue实例
 */
const syncCache = function (vue) {
  vue.$bus.emit(constants.EVENT_INIT_CACHE_COMPLETE)
}

/**
 * 添加一个好友
 * @param friend 好友信息，对象或数组
 * {
 *    uid: integer,         // 用户ID
 *    fid: integer,         // 好友ID
 *    name: string,         // 好友姓名
 *    avatar: string,       // 好友头像地址
 *    identityTags: object  // 好友身份标签,
      lastMsg: ''           // 最后一次发送/接收的消息
 *    lastTime: '',         // 最后一次发送/接收消息的时间
 * }
 * @returns {boolean} 添加成功返回true，否则返回false
 */
const addFriend = function (friend) {
  if (!friend || typeof(friend) !== 'object') {
    console.warn('无效的参数，添加好友失败')
    return false
  }

  if (Array.isArray(friend)) {
    let friendList = friend.filter((item) => !friendExists(item.fid))
    if (friendList.length > 0) {
      DB_INSTANCES[DB_FRIENDS].bulkDocs(friendList).then(function (response) {
        console.info(`${friendList.map((doc) => {
          return doc.fid
        }).join(',')}好友缓存成功：`, response)
      }).catch(function (err) {
        console.warn(`${friendList.map((doc) => {
          return doc.fid
        }).join(',')}好友缓存失败：`, err)
      })
    }
  } else {
    if (!friendExists(friend.id)) {
      DB_INSTANCES[DB_FRIENDS].post(friend).then(function (response) {
        console.info(`${friend.fid}好友缓存成功：`, response)
      }).catch(function (err) {
        console.warn(`${friend.fid}好友缓存失败：`, err)
      })
    }
  }
}

/**
 * 删除一个好友
 * @param uid 用户ID
 * @param fid 好友ID
 * @returns {boolean} 成功返回true，否则返回false
 */
const deleteFriend = function (uid, fid) {
  if (!uid || !fid) {
    console.warn(`删除好友失败，无效的参数：uid=${uid}, fid=${fid}`)
    return false
  }
  DB_INSTANCES[DB_FRIENDS].find({
    selector: {'uid': String(uid), 'fid': String(fid)},
    use_index: ['uid', 'fid']
  }).then(function (res) {
    if (res.docs.length < 1) {
      console.warn(`删除失败，${fid}不是${uid}的好友`)
      return
    }
    DB_INSTANCES[DB_FRIENDS].remove(res.docs[0])
    console.log(`删除${fid}好友成功`)
  }).catch(function (err) {
    console.warn('删除好友失败：', err)
  })
}

/**
 * 更新好友信息
 * @param friend 好友信息
 * @returns {boolean} 成功返回true，否则返回false
 */
const updateFriend = function (friend) {
  if (!friend || typeof(friend) !== 'object') {
    console.warn("无效的好友信息，更新好友信息失败")
    return false
  }

  DB_INSTANCES[DB_FRIENDS].find({
    selector: {'uid': String(friend.uid), fid: String(friend.fid)}
  }).then(function (res) {
    if (res.docs.length < 1) {
      console.warn(`更新好友信息失败，${friend.fid}不是${friend.uid}的好友`)
      return
    }
    let f = res.docs[0]
    Object.assign(f, friend)
    DB_INSTANCES[DB_FRIENDS].put(f)
    console.log(`更新${friend.fid}好友信息成功`)
  }).catch(function (err) {
    console.warn('更新好友信息失败：', err)
  })
}

/**
 * 更新好友最后一次发送/接收消息的内容和时间
 * @param uid           用户ID
 * @param fid           好友ID
 * @param lastMsg       最后一次发送的消息
 * @param lastTime      最后一次发送的时间
 */
const updateFriendLastMsg = function (uid, fid, lastMsg, lastTime) {
  DB_INSTANCES[DB_FRIENDS].find({
    selector: {uid: String(uid), fid: String(fid)},
    use_index: ['uid', 'fid']
  }).then(function (res) {
    if (res.docs.length < 1) {
      console.warn(`更新好友聊天信息失败，没有找到${fid}和${uid}的好友关系`)
      return
    }
    let f = res.docs[0]
    f.lastMsg = lastMsg || ''
    f.lastTime = lastTime || ''
    DB_INSTANCES[DB_FRIENDS].put(f)
    console.log(`${uid}与${fid}最后一次聊天信息更新成功`)
  }).catch(function (err) {
    console.warn('更新好友信息失败：', err)
  })
}

/**
 * 批量查询好友的信息
 * @param uid       用户ID
 * @param friendAccounts    好友ID列表,逗号分隔
 */
const getFriendsInfoForCache = function (uid, friendAccounts) {
  return DB_INSTANCES[DB_FRIENDS].find({
    "selector": {
      "fid": {
        "$in": friendAccounts
      }
    },
    use_index: ['fid']
  }).then(function (res) {
    let friends = []
    if (res.docs.length < 1) {
      console.log(`缓存中没有找到${uid}的好友列表`)
    } else {
      friends = res.docs.map((friend) => {
        return {
          id: friend.fid,
          name: friend.name,
          avatar: friend.avatar,
          identityTag: friend.identityTag,
          lastTime: friend.lastTime,
          lastMsg: friend.lastMsg
        }
      })
    }
    return friends
  }).catch(function (err) {
    let errInfo = `查询${uid}的${friendAccounts}好友信息失败：${err}`
    throw new Error(errInfo)
  })
}

/**
 * 查询好友是否存在
 * @param fid 好友ID
 */
const friendExists = function (fid) {
  return DB_INSTANCES[DB_FRIENDS].find({
    "selector": {
      "fid": {"$eq": fid}
    },
    use_index: ['fid']
  }).then(function (res) {
    return res.docs.length > 0
  }).catch(function (err) {
    console.warn(`friendExists-->查询${uid}的${fid}好友信息失败：${err}`)
    return false
  })
}

export default {
  init,
  release,
  clearDBCache,
  addFriend,
  deleteFriend,
  updateFriend,
  getFriendsInfoForCache,
  updateFriendLastMsg
}


// WEBPACK FOOTER //
// ./src/commons/cache.js
